540 research outputs found
Designing a Theorem Prover
A step-by-step presentation of the code for a small theorem prover introduces
theorem-proving techniques. The programming language used is Standard ML. The
prover operates on a sequent calculus formulation of first-order logic, which
is briefly explained. The implementation of unification and logical inference
is shown. The prover is demonstrated on several small examples, including one
that shows its limitations. The final part of the paper is a survey of
contemporary research on interactive theorem proving
A Formulation of the Simple Theory of Types (for Isabelle)
Simple type theory is formulated for use with the generic theorem prover
Isabelle. This requires explicit type inference rules. There are function,
product, and subset types, which may be empty. Descriptions (the eta-operator)
introduce the Axiom of Choice. Higher-order logic is obtained through
reflection between formulae and terms of type bool. Recursive types and
functions can be formally constructed. Isabelle proof procedures are described.
The logic appears suitable for general mathematics as well as computational
problems
Proving Termination of Normalization Functions for Conditional Expressions
Boyer and Moore have discussed a recursive function that puts conditional
expressions into normal form [1]. It is difficult to prove that this function
terminates on all inputs. Three termination proofs are compared: (1) using a
measure function, (2) in domain theory using LCF, (3) showing that its
recursion relation, defined by the pattern of recursive calls, is well-founded.
The last two proofs are essentially the same though conducted in markedly
different logical frameworks. An obviously total variant of the normalize
function is presented as the `computational meaning' of those two proofs. A
related function makes nested recursive calls. The three termination proofs
become more complex: termination and correctness must be proved simultaneously.
The recursion relation approach seems flexible enough to handle subtle
termination proofs where previously domain theory seemed essential
Constructing Recursion Operators in Intuitionistic Type Theory
Martin-L\"of's Intuitionistic Theory of Types is becoming popular for formal
reasoning about computer programs. To handle recursion schemes other than
primitive recursion, a theory of well-founded relations is presented. Using
primitive recursion over higher types, induction and recursion are formally
derived for a large class of well-founded relations. Included are < on natural
numbers, and relations formed by inverse images, addition, multiplication, and
exponentiation of other relations. The constructions are given in full detail
to allow their use in theorem provers for Type Theory, such as Nuprl. The
theory is compared with work in the field of ordinal recursion over higher
types
Generic Automatic Proof Tools
This book chapter establishes connections between the interactive proof tool
Isabelle and classical tableau and resolution technology. Isabelle's classical
reasoner is described and demonstrated by an extended case study: the
Church-Rosser theorem for combinators. Compared with other interactive theorem
provers, Isabelle's classical reasoner achieves a high degree of automation
Logic Programming, Functional Programming, and Inductive Definitions
An attempt at unifying logic and functional programming is reported. As a
starting point, we take the view that "logic programs" are not about logic but
constitute inductive definitions of sets and relations. A skeletal language
design based on these considerations is sketched and a prototype implementation
discussed
Deciding Univariate Polynomial Problems Using Untrusted Certificates in Isabelle/HOL
We present a proof procedure for univariate real polynomial problems in
Isabelle/HOL. The core mathematics of our procedure is based on univariate
cylindrical algebraic decomposition. We follow the approach of untrusted
certificates, separating solving from verifying: efficient external tools
perform expensive real algebraic computations, producing evidence that is
formally checked within Isabelle's logic. This allows us to exploit
highly-tuned computer algebra systems like Mathematica to guide our procedure
without impacting the correctness of its results. We present experiments
demonstrating the efficacy of this approach, in many cases yielding orders of
magnitude improvements over previous methods.Comment: 24 page
A Concrete Final Coalgebra Theorem for ZF Set Theory
A special final coalgebra theorem, in the style of Aczel's, is proved within
standard Zermelo-Fraenkel set theory. Aczel's Anti-Foundation Axiom is replaced
by a variant definition of function that admits non-well-founded constructions.
Variant ordered pairs and tuples, of possibly infinite length, are special
cases of variant functions. Analogues of Aczel's Solution and Substitution
Lemmas are proved in the style of Rutten and Turi. The approach is less general
than Aczel's, but the treatment of non-well-founded objects is simple and
concrete. The final coalgebra of a functor is its greatest fixedpoint. The
theory is intended for machine implementation and a simple case of it is
already implemented using the theorem prover Isabelle.Comment: a greatly revised version has appeared in Mathematical Structures in
Computer Science 9 (1999), 545-567. This version uses different methods and
therefore retains some valu
A Higher-Order Implementation of Rewriting
Many automatic theorem-provers rely on rewriting. Using theorems as rewrite
rules helps to simplify the subgoals that arise during a proof.
LCF is an interactive theorem-prover intended for reasoning about
computation. Its implementation of rewriting is presented in detail. LCF
provides a family of rewriting functions, and operators to combine them. A
succession of functions is described, from pattern matching primitives to the
rewriting tool that performs most inferences in LCF proofs.
The design is highly modular. Each function performs a basic, specific task,
such as recognizing a certain form of tautology. Each operator implements one
method of building a rewriting function from simpler ones. These pieces can be
put together in numerous ways, yielding a variety of rewrit- ing strategies.
The approach involves programming with higher-order functions. Rewriting
functions are data values, produced by computation on other rewriting
functions. The code is in daily use at Cambridge, demonstrating the practical
use of functional programming
Mechanizing Coinduction and Corecursion in Higher-order Logic
A theory of recursive and corecursive definitions has been developed in
higher-order logic (HOL) and mechanized using Isabelle. Least fixedpoints
express inductive data types such as strict lists; greatest fixedpoints express
coinductive data types, such as lazy lists. Well-founded recursion expresses
recursive functions over inductive data types; corecursion expresses functions
that yield elements of coinductive data types. The theory rests on a
traditional formalization of infinite trees. The theory is intended for use in
specification and verification. It supports reasoning about a wide range of
computable functions, but it does not formalize their operational semantics and
can express noncomputable functions also. The theory is illustrated using
finite and infinite lists. Corecursion expresses functions over infinite lists;
coinduction reasons about such functions
- …